home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / listings / v_08_09 / 8n09086a < prev    next >
Encoding:
Text File  |  1990-05-30  |  11.4 KB  |  526 lines
  1. /*
  2.      +--------------------------------------------------------------+
  3.      |    @(#) bfs_smon.c   v1.0   90/04/02                           |
  4.      |                                                              |
  5.      |  Copyright (C) 1990, StonyBrook Technologies, Inc.,          |
  6.      |  All Rights Reserved.                                        |
  7.      |                                                              |
  8.      |  This Module contains Proprietary Information of             |
  9.      |  StonyBrook Technologies, Inc. and should be treated         |
  10.      |  as Confidential.                                            |
  11.      |                                                              |
  12.      +--------------------------------------------------------------+
  13.  
  14.      bfs_smon.c - this is a file server daemon.
  15.  
  16. */
  17.  
  18. #include <stdio.h>
  19. #include <sys/fcntl.h>
  20. #include <sys/types.h>
  21. #include <sys/stat.h>
  22. #include <errno.h>
  23. #include <sys/signal.h>
  24. #include <varargs.h>
  25. #include <eicon/x25.h> 
  26. #include <eicon/x25errno.h> 
  27. #include "bfs.h"
  28.  
  29. static int running = 1;       /* running bit - can be modified on SIGINT */
  30.  
  31. int s_lcb_cnt;
  32. S_LCB s_lcb[MAX_S_LCB];
  33. S_SCB s_scb[MAX_S_SCB];
  34. char sname[16];
  35. char laddr[16];
  36.  
  37. struct x25doneinfo event;
  38.  
  39. /* debug stuff */
  40. int smon_io;
  41. char smon_buf[132];
  42. int debug_flag = 0;
  43.  
  44. signal_trap(in_signal)
  45. int in_signal;
  46. {
  47.     if(in_signal == SIGTERM) 
  48.         running = 0;   /* terminate when requested by outside */
  49. }
  50.  
  51.  
  52. cleanup_exit(exval)
  53. int exval;
  54. {
  55.   smon_term();
  56.   exit(exval);
  57. }
  58.  
  59. smon_term()
  60. {
  61.   sx25_term();
  62.   dprintf("BFS-SMON Terminating\n");
  63.   dclose();
  64. }
  65.  
  66.  
  67. smon_init()
  68. {
  69.   FILE *ifd;
  70.   char buf[132];
  71.   int i, foundme;
  72.  
  73.   dopen();
  74.  
  75.   for(i=0; i<MAX_S_SCB; i++) {
  76.     s_scb[i].lid = s_scb[i].csid = -1;
  77.     s_scb[i].fid = NULL;
  78.     s_scb[i].fname[0] = s_scb[i].ftype[0] = '\0';
  79.   }
  80.  
  81.   for(i=0; i<MAX_S_LCB; i++) {
  82.     s_lcb[i].cid = -1;
  83.     s_lcb[i].port = s_lcb[i].link = 0;
  84.     s_lcb[i].cname[0] = '\0';
  85.     s_lcb[i].raddr[0] = '\0';
  86.     s_lcb[i].cbuf = s_lcb[i].rbuf = s_lcb[i].dbuf = NULL;
  87.   }
  88.  
  89.   s_lcb_cnt = 0;
  90.   foundme = 0;
  91.  
  92.   if((ifd=fopen("clients", "r")) != NULL) {
  93.     while(fgets(buf, 132, ifd)) {
  94.       if((buf[0] != '#') && (sscanf(buf, "%s %d %s", s_lcb[s_lcb_cnt].cname,
  95.          &s_lcb[s_lcb_cnt].port, s_lcb[s_lcb_cnt].raddr) > 0)) {
  96.            if(!foundme) {
  97.              foundme = 1;
  98.              strcpy(sname, s_lcb[s_lcb_cnt].cname);
  99.              strcpy(laddr, s_lcb[s_lcb_cnt].raddr);
  100.            } else
  101.              s_lcb_cnt++;
  102.          }
  103.       }
  104.     fclose(ifd);
  105.   } else 
  106.     strcpy(sname, "NONAMESERVER");
  107.  
  108.   sx25_init();
  109. }
  110.  
  111.  
  112. main()
  113. {
  114.   int x25err;
  115.  
  116.   smon_init();
  117.  
  118.   dprintf("Basic File System - Server Monitor (BFS-SMON) Ver 1.0\n");
  119.   dprintf("Copyright (C) 1990, StonyBrook Technologies, Inc.\n");
  120.   dprintf("All Rights Reserved.\n");
  121.  
  122.   signal(SIGTERM, signal_trap);   /* setup signal handler */
  123.  
  124.   print_info();
  125.  
  126.   while(running) {
  127.     if(x25done(XD_ALLCONN, XD_NOTO, &event) != -1) {
  128.       switch(event.xi_code) {
  129.         case XC_LISTEN:
  130.           smon_listen_process();
  131.           break;
  132.         case XC_RECEIVE:
  133.          smon_receive_process();
  134.          break;
  135.       }
  136.     } else {
  137.       x25err = x25error();
  138.       dprintf("x25done error %d\n", x25err);
  139.       if(x25err >= ENOPEND)
  140.         running = 0;
  141.     }
  142.   }
  143.  
  144.   smon_term();
  145. }
  146.  
  147.  
  148. /* smon_listen, _receive processing routines */
  149.  
  150. smon_listen_process()
  151. {
  152.   int lid, cid;
  153.  
  154.   cid = event.xi_cid;
  155.   lid = find_lid(cid);
  156.   if(!event.xi_retcode) 
  157.     x25recv(cid, s_lcb[lid].cbuf, sizeof(RPC_FOPEN_CMD_MSG));
  158.   else {
  159.     dprintf("listen failed (%d) - client %s down\n",
  160.       event.xi_retcode, s_lcb[lid].cname);
  161.     s_lcb[lid].cid = -1;
  162.   }
  163. }
  164.  
  165.  
  166. smon_receive_process()
  167. {
  168.   RPC_CMD_MSG *rpc_msg;
  169.   int lid, cid, x25err;
  170.  
  171.   cid = event.xi_cid;
  172.   lid = find_lid(cid);
  173.   if(!event.xi_retcode) {
  174.     rpc_msg = (RPC_CMD_MSG *)s_lcb[lid].cbuf;
  175.     switch(rpc_msg->hdr.code) {
  176.       case RPC_FOPEN_CMD:
  177.         srpc_fopen(lid, (RPC_FOPEN_CMD_MSG *)rpc_msg);
  178.         break;
  179.       case RPC_FCLOSE_CMD:
  180.         srpc_fclose(lid, (RPC_FCLOSE_CMD_MSG *)rpc_msg);
  181.         break;
  182.       case RPC_FREAD_CMD:
  183.         srpc_fread(lid, (RPC_FREAD_CMD_MSG *)rpc_msg);
  184.         break;
  185.       case RPC_FWRITE_CMD:
  186.         srpc_fwrite(lid, (RPC_FWRITE_CMD_MSG *)rpc_msg);
  187.         break;
  188.       case RPC_FEOF_CMD:
  189.         srpc_feof(lid, (RPC_FEOF_CMD_MSG *)rpc_msg);
  190.         break;
  191.     } 
  192.   } else {
  193.     x25err = x25error();
  194.     if(x25err==ECALLCLR) {
  195.       dprintf("Call Clear line %d (cid=%d)\n", lid, cid);
  196.       if(x25listen(s_lcb[lid].raddr, laddr,     NULL,
  197.                    s_lcb[lid].port,  X25NOWAIT, &s_lcb[lid].cid) < 0)
  198.         dprintf("listen error %d - client %s down\n",
  199.           x25error(), s_lcb[lid].cname);
  200.     } else {
  201.       dprintf("Receive Error %d on line %d (cid=%d)\n", x25err, lid, cid);
  202.       x25recv(cid, s_lcb[lid].cbuf, sizeof(RPC_FOPEN_CMD_MSG));
  203.     }
  204.   } 
  205. }
  206.  
  207.  
  208. /* srpc_fopen, _fclose, _fread, _fwrite, _feof RPC protocol routines */
  209.  
  210. srpc_fopen(lid, focmd)
  211. int lid;
  212. RPC_FOPEN_CMD_MSG *focmd;
  213. {
  214.   RPC_FOPEN_RSP_MSG *forsp;
  215.   int csid, ssid;
  216.   
  217.   forsp = (RPC_FOPEN_RSP_MSG *)s_lcb[lid].rbuf;
  218.   csid = focmd->hdr.csid;
  219.   ssid = allocate_ssid(lid, csid);
  220.  
  221.   forsp->hdr.code = RPC_FOPEN_RSP;
  222.   forsp->hdr.csid = csid;
  223.   forsp->hdr.dlen = 0;
  224.  
  225.   if(ssid != -1) {
  226.     if((s_scb[ssid].fid = fopen(focmd->fname, focmd->ftype)) != NULL) {
  227.       forsp->hdr.ssid = ssid;
  228.       forsp->status = 0;
  229.       forsp->errno = 0;
  230.       s_scb[ssid].csid = csid;
  231.     } else {
  232.       forsp->hdr.ssid = -1;
  233.       forsp->status = -1;
  234.       forsp->errno = errno;
  235.       deallocate_ssid(ssid);
  236.     }
  237.   } else {
  238.     forsp->hdr.ssid = forsp->status = -1;
  239.     forsp->errno = ENXIO;
  240.   }
  241.   sx25_send_rsp(lid); 
  242. }
  243.  
  244. srpc_fclose(lid, fccmd)
  245. int lid;
  246. RPC_FCLOSE_CMD_MSG *fccmd;
  247. {
  248.   RPC_FCLOSE_RSP_MSG *fcrsp;
  249.   int csid, ssid;
  250.   
  251.   fcrsp = (RPC_FCLOSE_RSP_MSG *)s_lcb[lid].rbuf;
  252.   csid = fccmd->hdr.csid;
  253.   ssid = fccmd->hdr.ssid;
  254.  
  255.   fcrsp->hdr.code = RPC_FCLOSE_RSP;
  256.   fcrsp->hdr.csid = csid;
  257.   fcrsp->hdr.ssid = ssid;
  258.   fcrsp->hdr.dlen = 0;
  259.  
  260.   sx25_send_rsp(lid); 
  261. }
  262.  
  263. srpc_fread(lid, frcmd)
  264. int lid;
  265. RPC_FREAD_CMD_MSG *frcmd;
  266. {
  267.   RPC_FREAD_RSP_MSG *frrsp;
  268.   int csid, ssid, nitems, size;
  269.   
  270.   frrsp = (RPC_FREAD_RSP_MSG *)s_lcb[lid].rbuf;
  271.   csid = frcmd->hdr.csid;
  272.   ssid = frcmd->hdr.ssid;
  273.   nitems = frcmd->nitems;
  274.   size = frcmd->size;
  275.  
  276.   frrsp->hdr.code = RPC_FREAD_RSP;
  277.   frrsp->hdr.csid = csid;
  278.   frrsp->hdr.ssid = ssid;
  279.   frrsp->hdr.dlen = 0;
  280.  
  281.   frrsp->status = sfs_read(lid, s_scb[ssid].fid, nitems, size);
  282.   frrsp->errno = errno;
  283.   sx25_send_rsp(lid); 
  284.  
  285.   if(frrsp->status>0)
  286.     sx25_send_data(lid);
  287. }
  288.  
  289. srpc_fwrite(lid, fwcmd)
  290. int lid;
  291. RPC_FWRITE_CMD_MSG *fwcmd;
  292. {
  293.   RPC_FWRITE_RSP_MSG *fwrsp;
  294.   int csid, ssid, nitems, size, cnt;
  295.   
  296.   fwrsp = (RPC_FWRITE_RSP_MSG *)s_lcb[lid].rbuf;
  297.   csid = fwcmd->hdr.csid;
  298.   ssid = fwcmd->hdr.ssid;
  299.   nitems = fwcmd->nitems;
  300.   size = fwcmd->size;
  301.  
  302.   fwrsp->hdr.code = RPC_FWRITE_RSP;
  303.   fwrsp->hdr.csid = csid;
  304.   fwrsp->hdr.ssid = ssid;
  305.   fwrsp->hdr.dlen = 0;
  306.  
  307.   cnt = nitems * size;
  308.   sx25_recv_data(lid, cnt);
  309.   fwrsp->status = sfs_write(lid, s_scb[ssid].fid, nitems, size);
  310.   fwrsp->errno = errno;
  311.  
  312.   sx25_send_rsp(lid); 
  313. }
  314.  
  315. srpc_feof(lid, fecmd)
  316. int lid;
  317. RPC_FEOF_CMD_MSG *fecmd;
  318. {
  319.   RPC_FEOF_RSP_MSG *fersp;
  320.   int csid, ssid;
  321.   
  322.   fersp = (RPC_FEOF_RSP_MSG *)s_lcb[lid].rbuf;
  323.   csid = fecmd->hdr.csid;
  324.   ssid = fecmd->hdr.ssid;
  325.  
  326.   fersp->hdr.code = RPC_FEOF_RSP;
  327.   fersp->hdr.csid = csid;
  328.   fersp->hdr.ssid = ssid;
  329.   fersp->hdr.dlen = 0;
  330.  
  331.   fersp->status = feof(s_scb[ssid].fid);
  332.   fersp->errno = errno;
  333.  
  334.   sx25_send_rsp(lid); 
  335. }
  336.  
  337.  
  338. /* xs25_init, _term, _waitevent, _send_rsp, _send_data _recv_data
  339.    X.25 interface routines */
  340.  
  341. sx25_init()
  342. {
  343.   int i;
  344.  
  345.   x25init(0);
  346.  
  347.   for(i=0; i<s_lcb_cnt; i++)
  348.     if(x25listen(s_lcb[i].raddr, laddr,     NULL,
  349.                  s_lcb[i].port,  X25NOWAIT, &s_lcb[i].cid) != -1 ) {
  350.       s_lcb[i].cbuf = x25alloc(sizeof(RPC_FOPEN_CMD_MSG));              
  351.       s_lcb[i].rbuf = x25alloc(sizeof(RPC_RSP_MSG));              
  352.       dprintf("issue xlisten for %s at %s\n", s_lcb[i].cname, s_lcb[i].raddr);
  353.     } else {
  354.       dprintf("initial xlisten failed for %s - error %d\n",
  355.         s_lcb[i].cname, x25error());
  356.       s_lcb[i].cid = -1;
  357.     }
  358. }
  359.  
  360. sx25_term()
  361. {
  362.   int i;
  363.  
  364.   for(i=0; i<s_lcb_cnt; i++) {
  365.     if(s_lcb[i].cbuf != NULL)
  366.       x25free(s_lcb[i].cbuf);
  367.     if(s_lcb[i].rbuf != NULL)
  368.       x25free(s_lcb[i].rbuf);
  369.     if(s_lcb[i].cid != -1) {
  370.       dprintf("Clearing Call to Client %s\n", s_lcb[i].cname);
  371.       x25hangup(s_lcb[i].cid, NULL, XH_IMM);
  372.       sx25_waitevent(s_lcb[i].cid, XC_HANGUP, 0);
  373.     }
  374.   }
  375.   x25exit();
  376. }
  377.  
  378. sx25_waitevent(cid, etype, errchk)
  379. int cid, etype, errchk;
  380. {
  381.     if(x25done(cid, XD_NOTO, &event)<0)
  382.       dprintf("waitevent done error %d\n", x25error());
  383.     else if(errchk) {
  384.       if(event.xi_code != etype)
  385.         dprintf("waitevent expected %d - got %d\n", etype, event.xi_code);
  386.       if(event.xi_retcode)
  387.         dprintf("waitevent event error %d\n", x25error());
  388.     }
  389. }
  390.  
  391. sx25_send_rsp(lid)
  392. int lid;
  393. {
  394.   x25send(s_lcb[lid].cid, s_lcb[lid].rbuf, sizeof(RPC_RSP_MSG));
  395.   sx25_waitevent(s_lcb[lid].cid, XC_SEND, 0);
  396. }
  397.  
  398. sx25_send_data(lid, cnt)
  399. int lid, cnt;
  400. {
  401.   x25send(s_lcb[lid].cid, s_lcb[lid].dbuf, cnt);
  402.   sx25_waitevent(s_lcb[lid].cid, XC_SEND, 0);
  403.   x25free(s_lcb[lid].dbuf);
  404. }
  405.  
  406. sx25_recv_data(lid, cnt)
  407. int lid, cnt;
  408. {
  409.   s_lcb[lid].dbuf = x25alloc(cnt);
  410.   x25recv(s_lcb[lid].cid, s_lcb[lid].dbuf, cnt);
  411.   sx25_waitevent(s_lcb[lid].cid, XC_SEND, 0);
  412. }
  413.   
  414. /* file system utilities */
  415.  
  416. sfs_read(lid, fid, nitems, size)
  417. int lid, nitems, size;
  418. FILE *fid;
  419. {
  420.   int cnt;
  421.  
  422.   cnt = nitems * size;
  423.   errno = 0;
  424.   s_lcb[lid].dbuf = x25alloc(cnt);
  425.   if(s_lcb[lid].dbuf != NULL) {
  426.     return(fread(s_lcb[lid].dbuf, nitems, size, fid));
  427.   } else 
  428.     return(-1); 
  429. }
  430.  
  431. sfs_write(lid, fid, nitems, size)
  432. int lid, nitems, size;
  433. FILE *fid;
  434. {
  435.   int cnt;
  436.  
  437.   errno = 0;
  438.   cnt = fwrite(s_lcb[lid].dbuf, nitems, size, fid);
  439.   x25free(s_lcb[lid].dbuf);
  440.   return(cnt); 
  441. }
  442.  
  443.  
  444. /* session utilities */
  445.  
  446. allocate_ssid(lid, csid)
  447. int lid, csid;
  448. {
  449.   int ssid;
  450.  
  451.   for(ssid=0; ssid<MAX_S_SCB; ssid++)
  452.     if(s_scb[ssid].state == -1) {
  453.       s_scb[ssid].lid = lid;
  454.       s_scb[ssid].csid = csid;
  455.       s_scb[ssid].state = ssid;
  456.       return(ssid);
  457.     }
  458.   return(-1);
  459. }
  460.  
  461.  
  462. deallocate_ssid(ssid)
  463. int ssid;
  464. {
  465.   s_scb[ssid].state = -1;
  466. }
  467.  
  468.  
  469. find_lid(cid)
  470. int cid;
  471. {
  472.   int lid;
  473.  
  474.   for(lid=0; lid<s_lcb_cnt; lid++)
  475.     if(s_lcb[lid].cid == cid) return(lid);
  476.  
  477.   return(-1);
  478. }
  479.  
  480. /* debug utilities */
  481.  
  482. dopen()
  483. {
  484.   if((smon_io = open("/tmp/smon_io", O_WRONLY|O_CREAT, 0666)) != -1)
  485.     debug_flag = 1;
  486.   else
  487.     debug_flag = 0;
  488. }
  489.  
  490. dclose()
  491. {
  492.   if(debug_flag)
  493.     close(smon_io);
  494.   debug_flag = 0;
  495. }
  496.  
  497. dprintf(fmt, va_alist)
  498. char *fmt;
  499. va_dcl
  500. {
  501.   va_list ap;
  502.  
  503.   if(!debug_flag) return;
  504.   va_start(ap);
  505.   vsprintf(smon_buf, fmt, ap);
  506.   write(smon_io, smon_buf, strlen(smon_buf));
  507.   va_end(ap);
  508. }
  509.  
  510.  
  511. print_info()
  512. {
  513.     int i;
  514.  
  515.     dprintf("\nserver: %s  laddr: %s  - Total Clients: %d\n", 
  516.         sname, laddr, s_lcb_cnt);
  517.  
  518.     for(i=0; i<s_lcb_cnt; i++) 
  519.         dprintf(" client: %s  port: %d  raddr: %s\n",
  520.             s_lcb[i].cname, s_lcb[i].port, s_lcb[i].raddr);
  521. }
  522.  
  523.  
  524.  
  525.  
  526.